#include <iostream>
#include <thread>
int i = 0;
void test()
{
    int num = 10000;
    for (int n = 0; n < num; n++)
    {
        i++;
    }
}
int main()
{
    std::thread test_1(test);
    std::thread test_2(test);
    test_1.join();
    test_2.join();
    std::cout << i << std::endl;
    return 0;
}

// semaphore wMutex;      // 控制写操作的互斥信号量，初始值为 1
// semaphore rCountMutex; // 控制对 Rcount 的互斥修改，初始值为 1
// int rCount = 0;        // 正在进行读操作的读者个数，初始化为 0

// // 写者进程/线程执行的函数
// void writer()
// {
//     while (TRUE)
//     {
//         P(wMutex); // 进入临界区
//         write();
//         V(wMutex); // 进入临界区
//     }
// }
// // 读者进程/线程执行的函数
// void reader()
// {
//     while (TRUE)
//     {
//         P(rCountMutex); // 进入临界区
//         if (rCount == 0)
//         {
//             P(wMutex); // 如果有写者，则阻塞写者
//         }
//         rCount++;       // 读者计数 + 1
//         V(rCountMutex); // 离开临界区
//         read();         // 读数据
//         P(rCountMutex); // 进入临界区
//         rCount--;       // 读完数据，准备离开
//         if (rCount == 0)
//         {
//             V(wMutex); // 最后一个读者离开了，则唤醒写者
//         }
//         V(rCountMutex); // 离开临界区
//     }
// }

// semaphore rCountMutex;// 控制对 Rcount 的互斥修改，初始值为 1
// semaphore rMutex;//控制读者进入的互斥信号量者，初始值为 1
// semaphore wCountMutex// 控制 wCount 互斥修改，初始值为 1
// semaphore wDataMutex// 控制写者写操作的互斥信号量，初始值为1
// int rcount = 0;//正在进行读操作的读者个数，初始化为 0
// int wCount = 0;// 正在进行读操作的写者个数，初始化为 0
// //写者进程/线程执行的函数
// void writer()
// {
//     while(TRUE)
//     {
//         P(wCountMutex);// 进入临界区
//         if( wCount == 0)
//         {
//             P(rMutex); //当第一个写者进入，如果有读者则阻塞读者
//         }
//         wCount++;//写者计数 +1
//         V(wCountMutex); // 离开临界区
//         P(wDataMutex);//写者写操作之间互斥，进入临界区
//         write();//写数据
//         V(wDataMutex);// 离开临界区
//         P(wCountMutex);// 进入临界区
//         wCount--;// 写完数据，准备离开
//         if( wCount == 0 )
//         {
//             V(rMutex);//最后一个写者离开了，则唤醒读者
//         }
//         V(wCountMutex);//离开临界区
//     }
// }
// // 读者进程/线程执行的函数
// void reader()
// {
//     while(TRUE)
//     {
//         P(rMutex);
//         P(rCountMutex);// 进入临界区
//         if( rcount == 0 )
//         {
//             P(wDataMutex); // 当第一个读者进入，如果有写者则阻塞写者写操作
//         }
//         rCount++;
//         V(rCountMutex);//离开临界区
//         V(rMutex);
//         read();// 读数据
//         P(rCountMutex); //进入临界区
//         rCount--;
//         if( rCount ==0 )
//         {
//             V(wDataMutex); // 当没有读者了，则唤醒阻塞中写者的写操作
//         }
//         V(rCountMutex);//离开临界区
//     }
// }

